#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
LangChain Agent系统实现
包含Agent架构、提示词设计和执行器
"""

import asyncio
from typing import List, Dict, Any, Optional
import json

# 尝试导入LangChain Agent相关组件
try:
    # LangChain 1.0+ 新的导入路径
    from langchain.agents import AgentExecutor, create_openai_functions_agent
    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
    from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
    from langchain_openai import ChatOpenAI
    from langchain_core.callbacks import AsyncCallbackHandler
    AGENT_AVAILABLE = True
    print("LangChain Agent组件导入成功")
except ImportError as e:
    print(f"警告: LangChain Agent组件导入失败: {e}")
    print("尝试其他导入路径...")
    try:
        # 尝试从不同路径导入
        from langchain.agents.agent import AgentExecutor
        from langchain.agents.openai_functions.base import create_openai_functions_agent
        from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
        from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
        from langchain_openai import ChatOpenAI
        from langchain_core.callbacks import AsyncCallbackHandler
        AGENT_AVAILABLE = True
        print("使用备用导入路径成功")
    except ImportError as e2:
        print(f"所有Agent导入都失败: {e2}")
        print("使用简化模式...")
        try:
            # 最简化模式 - 只导入必要的组件
            from langchain_openai import ChatOpenAI
            from langchain_core.prompts import ChatPromptTemplate
            from langchain_core.callbacks import AsyncCallbackHandler
            AGENT_AVAILABLE = True
            AgentExecutor = None
            create_openai_functions_agent = None
            MessagesPlaceholder = None
            print("使用简化模式")
        except ImportError as e3:
            print(f"所有导入都失败: {e3}")
            AgentExecutor = None
            create_openai_functions_agent = None
            ChatOpenAI = None
            AsyncCallbackHandler = None
            MessagesPlaceholder = None
            AGENT_AVAILABLE = False

# 尝试导入工具和回调处理器
try:
    from agent_tools import TOOLS, AgentCallbackHandler
except ImportError:
    print("警告: 无法导入Agent工具，使用空工具列表")
    TOOLS = []
    AgentCallbackHandler = None


class TFTAgentSystem:
    """云顶之弈智能Agent系统"""

    def __init__(self, openai_api_key: str = None, model: str = "gpt-3.5-turbo"):
        """
        初始化Agent系统

        Args:
            openai_api_key: OpenAI API密钥
            model: 使用的模型
        """
        self.model = model
        self.openai_api_key = openai_api_key
        self.llm = None
        self.agent_executor = None
        self.callback_handler = None
        self.conversation_history = []

    async def initialize(self):
        """初始化Agent系统"""
        try:
            print("初始化LangChain Agent系统...")

            # 检查API密钥
            if not self.openai_api_key:
                raise Exception("未配置OpenAI API密钥，无法启动真实Agent系统")

            # 检查基本组件是否可用
            if not ChatOpenAI:
                raise Exception("ChatOpenAI组件不可用，请检查依赖安装")

            if not AGENT_AVAILABLE:
                print("警告: 完整Agent组件不可用，将使用简化模式")
                self.agent_executor = None

            # 获取API基础URL
            api_base = None
            import os
            if os.path.exists("config.json"):
                with open("config.json", 'r', encoding='utf-8') as f:
                    import json
                    config = json.load(f)
                    api_base = config.get('openai_api_base')

            # 初始化LLM配置
            llm_config = {
                "model": self.model,
                "api_key": self.openai_api_key,
                "temperature": 0.1,  # 降低随机性，提高一致性
                "streaming": True
            }

            # 如果有自定义API基础URL，添加到配置中
            if api_base:
                llm_config["base_url"] = api_base
                print(f"使用自定义API基础URL: {api_base}")

            self.llm = ChatOpenAI(**llm_config)
            print(f"LLM初始化成功 (模型: {self.model})")

            # 尝试创建完整Agent系统
            if (AgentExecutor and create_openai_functions_agent and
                ChatPromptTemplate and MessagesPlaceholder and TOOLS):
                print("创建完整Agent系统...")

                # 创建系统提示词
                system_prompt = self._create_system_prompt()

                # 创建Agent提示词模板
                prompt = ChatPromptTemplate.from_messages([
                    ("system", system_prompt),
                    ("human", "{input}"),
                    MessagesPlaceholder(variable_name="agent_scratchpad"),
                ])

                # 检查工具是否可用
                if not AgentCallbackHandler:
                    print("警告: Agent回调处理器不可用，将不使用回调")

                # 创建Agent
                self.agent = create_openai_functions_agent(
                    llm=self.llm,
                    tools=TOOLS,
                    prompt=prompt
                )
                print("Agent创建成功")

                # 创建Agent执行器
                if AgentCallbackHandler:
                    self.callback_handler = AgentCallbackHandler()
                    callbacks = [self.callback_handler]
                else:
                    callbacks = []

                self.agent_executor = AgentExecutor(
                    agent=self.agent,
                    tools=TOOLS,
                    callbacks=callbacks,
                    verbose=True,  # 显示详细执行过程
                    return_intermediate_steps=True,  # 返回中间步骤
                    max_iterations=3,  # 限制最大迭代次数
                )
                print("Agent执行器创建成功")
            else:
                print("Agent组件不完整，跳过Agent创建")
                self.agent_executor = None
                print("将使用简化的LLM模式")

            print("LangChain Agent系统初始化完成")
            return True

        except Exception as e:
            print(f"Agent系统初始化失败: {e}")
            print("系统需要真实API密钥才能运行")
            return False

    def _create_system_prompt(self) -> str:
        """创建系统提示词"""
        return """你是一个专业的云顶之弈智能助手，拥有多种信息获取工具。

## 🎯 你的核心能力：
1. **联网搜索** - 获取最新新闻、产品评价、技术资讯等实时信息
2. **本地知识库** - 查询游戏基础规则、历史数据、教学指南
3. **OPGG实时数据** - 获取游戏Meta、阵容排行、装备数据

## 🤖 工作原则：
1. **智能决策**: 根据用户问题自主决定是否需要使用工具以及使用哪些工具
2. **精准搜索**: 如果需要搜索，优化搜索关键词以获得最佳结果
3. **深度分析**: 基于工具返回的信息进行深入分析和总结
4. **用户导向**: 生成有用、准确、易于理解的回答

## 🔍 工具使用指导：

### web_search (联网搜索)
- **适用场景**: 最新新闻、产品评价、公司动态、技术趋势
- **关键词优化**: 添加时间词(最新、最近)、品牌名、具体产品名
- **示例**: "小米汽车最新评价" 而不是 "小米怎么样"

### local_knowledge (本地知识库)
- **适用场景**: 游戏规则、基础概念、历史信息、教学指南
- **特点**: 响应快速，信息稳定可靠
- **示例**: "云顶之弈基础规则"、"装备合成机制"

### opgg_data (游戏数据)
- **适用场景**: 游戏Meta、阵容排行、装备强度、英雄数据
- **特点**: 实时更新，数据权威
- **示例**: "当前版本最强阵容"、"热门装备排行"

## 💡 回答风格：
- **结构化**: 使用标题、列表、分段提高可读性
- **数据驱动**: 基于工具返回的具体信息生成回答
- **实用导向**: 提供有价值的信息和建议
- **适度详细**: 既要全面又要简洁，避免信息过载

## ⚠️ 重要提醒：
- 如果工具未返回相关信息，尝试不同的搜索策略
- 多个来源的信息需要交叉验证和平衡
- 对于推测性内容，明确说明基于哪些信息
- 保持客观中立，避免主观臆断

现在请根据用户的问题，智能使用工具并提供专业、有用的回答！"""

    async def process_query(self, query: str) -> Dict[str, Any]:
        """处理用户查询"""
        try:
            print(f"\nAgent开始处理: {query}")
            print("=" * 50)

            # 添加到对话历史
            self.conversation_history.append({
                "role": "user",
                "content": query,
                "timestamp": asyncio.get_event_loop().time()
            })

            # 检查是否有完整的Agent系统
            if hasattr(self, 'agent_executor') and self.agent_executor is not None:
                # 使用完整Agent系统
                result = await self.agent_executor.ainvoke({
                    "input": query
                })

                # 提取中间步骤（Agent的思考过程）
                intermediate_steps = result.get("intermediate_steps", [])
                thoughts = []
                for step in intermediate_steps:
                    if len(step) >= 2:
                        action, observation = step[0], step[1]
                        thoughts.append({
                            "action": action,
                            "observation": observation
                        })

                output = result.get("output", "")
                tool_usage = len([s for s in intermediate_steps if s and len(s) >= 2])

                return {
                    "output": output,
                    "intermediate_steps": thoughts,
                    "agent_scratchpad": result.get("agent_scratchpad", ""),
                    "tool_usage": tool_usage,
                    "success": True
                }
            else:
                # 使用简化LLM模式
                print("使用简化LLM模式处理查询")

                # 创建简化的系统提示词
                system_prompt = """你是一个专业的云顶之弈智能助手，擅长回答各种问题。

你的能力包括：
1. 回答关于云顶之弈游戏的问题
2. 分析最新的科技趋势和新闻
3. 提供实用的建议和信息
4. 进行多轮对话

请用中文回答，回答要准确、有用、易于理解。"""

                # 构建完整提示词
                if ChatPromptTemplate:
                    try:
                        prompt_template = ChatPromptTemplate.from_messages([
                            ("system", system_prompt),
                            ("human", "{input}"),
                        ])
                        prompt = prompt_template.format(input=query)
                    except:
                        prompt = f"系统：{system_prompt}\n\n用户：{query}\n\n助手："
                else:
                    prompt = f"系统：{system_prompt}\n\n用户：{query}\n\n助手："

                # 直接调用LLM
                response = self.llm.invoke(prompt)
                output = response.content

                return {
                    "output": output,
                    "intermediate_steps": [],
                    "agent_scratchpad": "",
                    "tool_usage": 0,
                    "success": True,
                    "mode": "simplified_llm"
                }

        except Exception as e:
            error_msg = f"处理失败: {str(e)}"
            print(f"错误: {error_msg}")

            self.conversation_history.append({
                "role": "system",
                "content": error_msg,
                "timestamp": asyncio.get_event_loop().time()
            })

            return {
                "output": f"抱歉，处理您的查询时遇到了问题：{str(e)}\n\n建议：\n1. 检查API密钥配置\n2. 确认网络连接正常\n3. 重新表述您的问题",
                "intermediate_steps": [],
                "agent_scratchpad": "",
                "tool_usage": 0,
                "success": False,
                "error": str(e)
            }

    def get_conversation_summary(self) -> str:
        """获取对话摘要"""
        if not self.conversation_history:
            return "暂无对话记录"

        summary = f"对话记录 (共{len(self.conversation_history)}条消息):\n\n"

        for i, msg in enumerate(self.conversation_history[-5:], 1):  # 只显示最近5条
            role_icon = "👤" if msg["role"] == "user" else "🤖" if msg["role"] == "assistant" else "⚙️"
            summary += f"{i}. {role_icon} {msg['content'][:100]}{'...' if len(msg['content']) > 100 else ''}\n"

        return summary

    def clear_history(self):
        """清空对话历史"""
        self.conversation_history = []
        print("🧹 对话历史已清空")


# MockLLM类已移除 - 系统必须使用真实API


class AgentOrchestrator:
    """Agent协调器，管理整个Agent生命周期"""

    def __init__(self):
        self.agent_system = None
        self.is_initialized = False

    async def initialize(self, openai_api_key: str = None, model: str = "gpt-3.5-turbo"):
        """初始化Agent系统"""
        if self.is_initialized:
            return True

        self.agent_system = TFTAgentSystem(openai_api_key, model)
        success = await self.agent_system.initialize()

        if success:
            self.is_initialized = True
            print("Agent系统就绪")
        else:
            print("Agent系统初始化失败，将使用基础功能")

        return success

    async def process_query(self, query: str) -> Dict[str, Any]:
        """处理查询"""
        if not self.is_initialized:
            return {
                "output": "Agent系统未初始化，请稍后重试或使用其他功能。",
                "success": False
            }

        return await self.agent_system.process_query(query)

    def get_status(self) -> Dict[str, Any]:
        """获取系统状态"""
        return {
            "initialized": self.is_initialized,
            "model": self.agent_system.model if self.agent_system else "N/A",
            "conversation_count": len(self.agent_system.conversation_history) if self.agent_system else 0,
            "available_tools": len(TOOLS)
        }

    def clear_history(self):
        """清空历史"""
        if self.agent_system:
            self.agent_system.clear_history()


# 全局Agent实例
agent_orchestrator = AgentOrchestrator()


# 测试代码
async def test_agent_system():
    """测试Agent系统"""
    print("🧪 测试LangChain Agent系统...")

    # 初始化（需要API密钥进行真实测试）
    success = await agent_orchestrator.initialize()

    if success:
        # 测试查询
        test_queries = [
            "小米汽车最新发展情况如何？",
            "云顶之弈基础规则是什么？",
            "当前版本什么阵容最强？"
        ]

        for query in test_queries:
            print(f"\n测试查询: {query}")
            result = await agent_orchestrator.process_query(query)
            print(f"回答长度: {len(result.get('output', ''))}")
            print(f"使用工具数量: {result.get('tool_usage', 0)}")
            print("-" * 30)

        # 显示对话摘要
        print("\n对话摘要:")
        print(agent_orchestrator.get_conversation_summary())
    else:
        print("❌ Agent系统初始化失败")


if __name__ == "__main__":
    asyncio.run(test_agent_system())